import axios from 'axios'
import Cookie from 'js-cookie'

// 跨域认证信息 header 名
const xsrfHeaderName = 'Authorization'

axios.defaults.timeout = 5000
axios.defaults.withCredentials = true
axios.defaults.xsrfHeaderName = xsrfHeaderName
axios.defaults.xsrfCookieName = xsrfHeaderName

// 认证类型
const AUTH_TYPE = {
    BEARER: 'Bearer',
    BASIC: 'basic',
    AUTH1: 'auth1',
    AUTH2: 'auth2',
}

// http method
const METHOD = {
    GET: 'get',
    POST: 'post'
}
/**
 * axios请求
 * @param url 请求地址
 * @param method {METHOD} http method
 * @param params 请求参数
 * @returns {Promise<AxiosResponse<T>>}
 */
//跨域代理前缀
const API_PROXY_PREFIX='/api';
//  development:开发环境  production：生产环境
const Dev_PROXY_PREFIX='http://121.196.39.32/admin-facade';//开发接口
const Pro_PROXY_PREFIX='http://localhost:5200/gege';//生产接口


function request(config) {
    const instance = axios.create({
        baseURL : process.env.NODE_ENV === 'production' ?  Pro_PROXY_PREFIX: Dev_PROXY_PREFIX,
        headers: {
             "Content-Type": "application/json",
         },
      })
      //请求拦截器
      instance.interceptors.request.use((config) => {
          //请求成功时的一些操作
          if (localStorage.getItem('Authorization')) {
            config.headers.Authorization = localStorage.getItem('Authorization');
          }
          return config;
        }
        , (error) => {
          //请求失败时的一些操作 
          return Promise.reject(error);
        })
      //响应拦截器
      instance.interceptors.response.use((response) => {
          //响应成功时的一些操作
          return Promise.resolve(response)
        }
        , (error) => {
          //响应失败时的一些操作
        })
        return instance(config)
}

/**
 * 设置认证信息
 * @param auth {Object}
 * @param authType {AUTH_TYPE} 认证类型，默认：{AUTH_TYPE.BEARER}
 */
function setAuthorization(auth, authType = AUTH_TYPE.BEARER) {
    switch (authType) {
        case AUTH_TYPE.BEARER:
            Cookie.set(xsrfHeaderName, 'Bearer ' + auth.token, { expires: auth.expireAt })
            break
        case AUTH_TYPE.BASIC:
        case AUTH_TYPE.AUTH1:
        case AUTH_TYPE.AUTH2:
        default:
            break
    }
}

/**
 * 移出认证信息
 * @param authType {AUTH_TYPE} 认证类型
 */
function removeAuthorization(authType = AUTH_TYPE.BEARER) {
    switch (authType) {
        case AUTH_TYPE.BEARER:
            Cookie.remove(xsrfHeaderName)
            break
        case AUTH_TYPE.BASIC:
        case AUTH_TYPE.AUTH1:
        case AUTH_TYPE.AUTH2:
        default:
            break
    }
}

/**
 * 检查认证信息
 * @param authType
 * @returns {boolean}
 */
function checkAuthorization(authType = AUTH_TYPE.BEARER) {
    switch (authType) {
        case AUTH_TYPE.BEARER:
            if (Cookie.get(xsrfHeaderName)) {
                return true
            }
            break
        case AUTH_TYPE.BASIC:
        case AUTH_TYPE.AUTH1:
        case AUTH_TYPE.AUTH2:
        default:
            break
    }
    return false
}

/**
 * 解析 url 中的参数
 * @param url
 * @returns {Object}
 */
function parseUrlParams(url) {
    const params = {}
    if (!url || url === '' || typeof url !== 'string') {
        return params
    }
    const paramsStr = url.split('?')[1]
    if (!paramsStr) {
        return params
    }
    const paramsArr = paramsStr.replace(/&|=/g, ' ').split(' ')
    for (let i = 0; i < paramsArr.length / 2; i++) {
        const value = paramsArr[i * 2 + 1]
        params[paramsArr[i * 2]] = value === 'true' ? true : (value === 'false' ? false : value)
    }
    return `params`
}

export {
    // METHOD,                 //http method 常量
    AUTH_TYPE,              //凭证认证类型 常量
    request,                //http请求函数
    setAuthorization,       //设置身份凭证函数
    removeAuthorization,    //移除身份凭证函数
    checkAuthorization,     //检查身份凭证是否过期函数
    // parseUrlParams
}